package com.gitee.qdbp.general.common.api.oplog.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.general.common.enums.LogProcessState;
import com.gitee.qdbp.general.common.enums.LogRequestType;
import com.gitee.qdbp.general.common.enums.LogResultType;

/**
 * 操作记录查询类
 *
 * @author zhh
 * @version 180119
 */
public class OperateRecordWhere extends OperateRecordBean {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 主键列表 **/
    private List<String> ids;

    /** 主键前模匹配条件 **/
    private String idStarts;

    /** 主键后模匹配条件 **/
    private String idEnds;

    /** 主键模糊查询条件 **/
    private String idLike;

    /** 租户编号空值/非空值查询 **/
    private Boolean tenantCodeIsNull;

    /** 租户编号前模匹配条件 **/
    private String tenantCodeStarts;

    /** 租户编号后模匹配条件 **/
    private String tenantCodeEnds;

    /** 租户编号模糊查询条件 **/
    private String tenantCodeLike;

    /** 工程空值/非空值查询 **/
    private Boolean projectIsNull;

    /** 工程前模匹配条件 **/
    private String projectStarts;

    /** 工程后模匹配条件 **/
    private String projectEnds;

    /** 工程模糊查询条件 **/
    private String projectLike;

    /** 分组空值/非空值查询 **/
    private Boolean groupsIsNull;

    /** 分组前模匹配条件 **/
    private String groupsStarts;

    /** 分组后模匹配条件 **/
    private String groupsEnds;

    /** 分组模糊查询条件 **/
    private String groupsLike;

    /** 用户ID空值/非空值查询 **/
    private Boolean userIdIsNull;

    /** 用户ID前模匹配条件 **/
    private String userIdStarts;

    /** 用户ID后模匹配条件 **/
    private String userIdEnds;

    /** 用户ID模糊查询条件 **/
    private String userIdLike;

    /** 用户名空值/非空值查询 **/
    private Boolean userNameIsNull;

    /** 用户名前模匹配条件 **/
    private String userNameStarts;

    /** 用户名后模匹配条件 **/
    private String userNameEnds;

    /** 用户名模糊查询条件 **/
    private String userNameLike;

    /** 商家租户编号空值/非空值查询 **/
    private Boolean providerTenantCodeIsNull;

    /** 商家租户编号前模匹配条件 **/
    private String providerTenantCodeStarts;

    /** 商家租户编号后模匹配条件 **/
    private String providerTenantCodeEnds;

    /** 商家租户编号模糊查询条件 **/
    private String providerTenantCodeLike;

    /** 客服租户编号空值/非空值查询 **/
    private Boolean agentTenantCodeIsNull;

    /** 客服租户编号前模匹配条件 **/
    private String agentTenantCodeStarts;

    /** 客服租户编号后模匹配条件 **/
    private String agentTenantCodeEnds;

    /** 客服租户编号模糊查询条件 **/
    private String agentTenantCodeLike;

    /** 客服ID空值/非空值查询 **/
    private Boolean agentIdIsNull;

    /** 客服ID前模匹配条件 **/
    private String agentIdStarts;

    /** 客服ID后模匹配条件 **/
    private String agentIdEnds;

    /** 客服ID模糊查询条件 **/
    private String agentIdLike;

    /** 客服姓名空值/非空值查询 **/
    private Boolean agentNameIsNull;

    /** 客服姓名前模匹配条件 **/
    private String agentNameStarts;

    /** 客服姓名后模匹配条件 **/
    private String agentNameEnds;

    /** 客服姓名模糊查询条件 **/
    private String agentNameLike;

    /** 是否代客操作空值/非空值查询 **/
    private Boolean agencyOperateIsNull;

    /** IP空值/非空值查询 **/
    private Boolean ipIsNull;

    /** IP前模匹配条件 **/
    private String ipStarts;

    /** IP后模匹配条件 **/
    private String ipEnds;

    /** IP模糊查询条件 **/
    private String ipLike;

    /** 城市空值/非空值查询 **/
    private Boolean cityIsNull;

    /** 城市前模匹配条件 **/
    private String cityStarts;

    /** 城市后模匹配条件 **/
    private String cityEnds;

    /** 城市模糊查询条件 **/
    private String cityLike;

    /** 请求类型(1.页面|2.接口)空值/非空值查询 **/
    private Boolean requestTypeIsNull;

    /** 请求类型(1.页面|2.接口)列表 **/
    private List<LogRequestType> requestTypes;

    /** 请求协议空值/非空值查询 **/
    private Boolean requestProtocolIsNull;

    /** 请求协议前模匹配条件 **/
    private String requestProtocolStarts;

    /** 请求协议后模匹配条件 **/
    private String requestProtocolEnds;

    /** 请求协议模糊查询条件 **/
    private String requestProtocolLike;

    /** 请求方法空值/非空值查询 **/
    private Boolean requestMethodIsNull;

    /** 请求方法前模匹配条件 **/
    private String requestMethodStarts;

    /** 请求方法后模匹配条件 **/
    private String requestMethodEnds;

    /** 请求方法模糊查询条件 **/
    private String requestMethodLike;

    /** 请求URL空值/非空值查询 **/
    private Boolean requestUrlIsNull;

    /** 请求URL前模匹配条件 **/
    private String requestUrlStarts;

    /** 请求URL后模匹配条件 **/
    private String requestUrlEnds;

    /** 请求URL模糊查询条件 **/
    private String requestUrlLike;

    /** 请求参数空值/非空值查询 **/
    private Boolean requestParamsIsNull;

    /** 请求参数前模匹配条件 **/
    private String requestParamsStarts;

    /** 请求参数后模匹配条件 **/
    private String requestParamsEnds;

    /** 请求参数模糊查询条件 **/
    private String requestParamsLike;

    /** 执行描述空值/非空值查询 **/
    private Boolean executeDescIsNull;

    /** 执行描述前模匹配条件 **/
    private String executeDescStarts;

    /** 执行描述后模匹配条件 **/
    private String executeDescEnds;

    /** 执行描述模糊查询条件 **/
    private String executeDescLike;

    /** 执行方法空值/非空值查询 **/
    private Boolean executeMethodIsNull;

    /** 执行方法前模匹配条件 **/
    private String executeMethodStarts;

    /** 执行方法后模匹配条件 **/
    private String executeMethodEnds;

    /** 执行方法模糊查询条件 **/
    private String executeMethodLike;

    /** 执行时间空值/非空值查询 **/
    private Boolean executeTimeIsNull;

    /** 最小执行时间 **/
    private Integer executeTimeMin;

    /** 最大执行时间 **/
    private Integer executeTimeMax;

    /** 调用DB次数空值/非空值查询 **/
    private Boolean dbInvokeTimesIsNull;

    /** 最小调用DB次数 **/
    private Integer dbInvokeTimesMin;

    /** 最大调用DB次数 **/
    private Integer dbInvokeTimesMax;

    /** 结果类型(1.成功|2.失败|3.未知)空值/非空值查询 **/
    private Boolean returnTypeIsNull;

    /** 结果类型(1.成功|2.失败|3.未知)列表 **/
    private List<LogResultType> returnTypes;

    /** 返回码空值/非空值查询 **/
    private Boolean returnCodeIsNull;

    /** 返回码前模匹配条件 **/
    private String returnCodeStarts;

    /** 返回码后模匹配条件 **/
    private String returnCodeEnds;

    /** 返回码模糊查询条件 **/
    private String returnCodeLike;

    /** 返回内容空值/非空值查询 **/
    private Boolean returnContentIsNull;

    /** 返回内容前模匹配条件 **/
    private String returnContentStarts;

    /** 返回内容后模匹配条件 **/
    private String returnContentEnds;

    /** 返回内容模糊查询条件 **/
    private String returnContentLike;

    /** 来源页空值/非空值查询 **/
    private Boolean refererUrlIsNull;

    /** 来源页前模匹配条件 **/
    private String refererUrlStarts;

    /** 来源页后模匹配条件 **/
    private String refererUrlEnds;

    /** 来源页模糊查询条件 **/
    private String refererUrlLike;

    /** 入口空值/非空值查询 **/
    private Boolean entranceIsNull;

    /** 来源类型空值/非空值查询 **/
    private Boolean refererTypeIsNull;

    /** 来源类型前模匹配条件 **/
    private String refererTypeStarts;

    /** 来源类型后模匹配条件 **/
    private String refererTypeEnds;

    /** 来源类型模糊查询条件 **/
    private String refererTypeLike;

    /** 来源关键词空值/非空值查询 **/
    private Boolean refererKeywordIsNull;

    /** 来源关键词前模匹配条件 **/
    private String refererKeywordStarts;

    /** 来源关键词后模匹配条件 **/
    private String refererKeywordEnds;

    /** 来源关键词模糊查询条件 **/
    private String refererKeywordLike;

    /** UserAgent空值/非空值查询 **/
    private Boolean userAgentIsNull;

    /** UserAgent前模匹配条件 **/
    private String userAgentStarts;

    /** UserAgent后模匹配条件 **/
    private String userAgentEnds;

    /** UserAgent模糊查询条件 **/
    private String userAgentLike;

    /** 浏览器类型空值/非空值查询 **/
    private Boolean browserTypeIsNull;

    /** 浏览器类型前模匹配条件 **/
    private String browserTypeStarts;

    /** 浏览器类型后模匹配条件 **/
    private String browserTypeEnds;

    /** 浏览器类型模糊查询条件 **/
    private String browserTypeLike;

    /** 浏览器版本空值/非空值查询 **/
    private Boolean browserVersionIsNull;

    /** 浏览器版本前模匹配条件 **/
    private String browserVersionStarts;

    /** 浏览器版本后模匹配条件 **/
    private String browserVersionEnds;

    /** 浏览器版本模糊查询条件 **/
    private String browserVersionLike;

    /** 操作系统类型空值/非空值查询 **/
    private Boolean osTypeIsNull;

    /** 操作系统类型前模匹配条件 **/
    private String osTypeStarts;

    /** 操作系统类型后模匹配条件 **/
    private String osTypeEnds;

    /** 操作系统类型模糊查询条件 **/
    private String osTypeLike;

    /** 操作系统版本空值/非空值查询 **/
    private Boolean osVersionIsNull;

    /** 操作系统版本前模匹配条件 **/
    private String osVersionStarts;

    /** 操作系统版本后模匹配条件 **/
    private String osVersionEnds;

    /** 操作系统版本模糊查询条件 **/
    private String osVersionLike;

    /** 设备类型空值/非空值查询 **/
    private Boolean deviceTypeIsNull;

    /** 设备类型前模匹配条件 **/
    private String deviceTypeStarts;

    /** 设备类型后模匹配条件 **/
    private String deviceTypeEnds;

    /** 设备类型模糊查询条件 **/
    private String deviceTypeLike;

    /** 处理状态(1.未处理|2.已处理)空值/非空值查询 **/
    private Boolean processStateIsNull;

    /** 处理状态(1.未处理|2.已处理)列表 **/
    private List<LogProcessState> processStates;

    /** 最小创建时间 **/
    private Date createTimeMin;

    /** 最大创建时间 **/
    private Date createTimeMax;

    /** 最小创建时间 **/
    private Date createTimeMinWithDay;

    /** 最大创建时间 **/
    private Date createTimeMaxWithDay;

    /** 选项空值/非空值查询 **/
    private Boolean optionsIsNull;


    /** 获取主键列表 **/
    public List<String> getIds() {
        return ids;
    }

    /** 设置主键列表 **/
    public void setIds(List<String> ids) {
        this.ids = ids;
    }

    /** 增加主键 **/
    public void addId(String... ids) {
        if (this.ids == null) {
            this.ids = new ArrayList<>();
        }
        this.ids.addAll(Arrays.asList(ids));
    }

    /** 获取主键前模匹配条件 **/
    public String getIdStarts() {
        return idStarts;
    }

    /** 设置主键前模匹配条件 **/
    public void setIdStarts(String idStarts) {
        this.idStarts = idStarts;
    }

    /** 获取主键后模匹配条件 **/
    public String getIdEnds() {
        return idEnds;
    }

    /** 设置主键后模匹配条件 **/
    public void setIdEnds(String idEnds) {
        this.idEnds = idEnds;
    }

    /** 获取主键模糊查询条件 **/
    public String getIdLike() {
        return idLike;
    }

    /** 设置主键模糊查询条件 **/
    public void setIdLike(String idLike) {
        this.idLike = idLike;
    }

    /** 判断租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTenantCodeIsNull() {
        return tenantCodeIsNull;
    }

    /** 设置租户编号空值查询(true:空值查询|false:非空值查询) **/
    public void setTenantCodeIsNull(Boolean tenantCodeIsNull) {
        this.tenantCodeIsNull = tenantCodeIsNull;
    }

    /** 获取租户编号前模匹配条件 **/
    public String getTenantCodeStarts() {
        return tenantCodeStarts;
    }

    /** 设置租户编号前模匹配条件 **/
    public void setTenantCodeStarts(String tenantCodeStarts) {
        this.tenantCodeStarts = tenantCodeStarts;
    }

    /** 获取租户编号后模匹配条件 **/
    public String getTenantCodeEnds() {
        return tenantCodeEnds;
    }

    /** 设置租户编号后模匹配条件 **/
    public void setTenantCodeEnds(String tenantCodeEnds) {
        this.tenantCodeEnds = tenantCodeEnds;
    }

    /** 获取租户编号模糊查询条件 **/
    public String getTenantCodeLike() {
        return tenantCodeLike;
    }

    /** 设置租户编号模糊查询条件 **/
    public void setTenantCodeLike(String tenantCodeLike) {
        this.tenantCodeLike = tenantCodeLike;
    }

    /** 判断工程是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProjectIsNull() {
        return projectIsNull;
    }

    /** 设置工程空值查询(true:空值查询|false:非空值查询) **/
    public void setProjectIsNull(Boolean projectIsNull) {
        this.projectIsNull = projectIsNull;
    }

    /** 获取工程前模匹配条件 **/
    public String getProjectStarts() {
        return projectStarts;
    }

    /** 设置工程前模匹配条件 **/
    public void setProjectStarts(String projectStarts) {
        this.projectStarts = projectStarts;
    }

    /** 获取工程后模匹配条件 **/
    public String getProjectEnds() {
        return projectEnds;
    }

    /** 设置工程后模匹配条件 **/
    public void setProjectEnds(String projectEnds) {
        this.projectEnds = projectEnds;
    }

    /** 获取工程模糊查询条件 **/
    public String getProjectLike() {
        return projectLike;
    }

    /** 设置工程模糊查询条件 **/
    public void setProjectLike(String projectLike) {
        this.projectLike = projectLike;
    }

    /** 判断分组是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getGroupsIsNull() {
        return groupsIsNull;
    }

    /** 设置分组空值查询(true:空值查询|false:非空值查询) **/
    public void setGroupsIsNull(Boolean groupsIsNull) {
        this.groupsIsNull = groupsIsNull;
    }

    /** 获取分组前模匹配条件 **/
    public String getGroupsStarts() {
        return groupsStarts;
    }

    /** 设置分组前模匹配条件 **/
    public void setGroupsStarts(String groupsStarts) {
        this.groupsStarts = groupsStarts;
    }

    /** 获取分组后模匹配条件 **/
    public String getGroupsEnds() {
        return groupsEnds;
    }

    /** 设置分组后模匹配条件 **/
    public void setGroupsEnds(String groupsEnds) {
        this.groupsEnds = groupsEnds;
    }

    /** 获取分组模糊查询条件 **/
    public String getGroupsLike() {
        return groupsLike;
    }

    /** 设置分组模糊查询条件 **/
    public void setGroupsLike(String groupsLike) {
        this.groupsLike = groupsLike;
    }

    /** 判断用户ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUserIdIsNull() {
        return userIdIsNull;
    }

    /** 设置用户ID空值查询(true:空值查询|false:非空值查询) **/
    public void setUserIdIsNull(Boolean userIdIsNull) {
        this.userIdIsNull = userIdIsNull;
    }

    /** 获取用户ID前模匹配条件 **/
    public String getUserIdStarts() {
        return userIdStarts;
    }

    /** 设置用户ID前模匹配条件 **/
    public void setUserIdStarts(String userIdStarts) {
        this.userIdStarts = userIdStarts;
    }

    /** 获取用户ID后模匹配条件 **/
    public String getUserIdEnds() {
        return userIdEnds;
    }

    /** 设置用户ID后模匹配条件 **/
    public void setUserIdEnds(String userIdEnds) {
        this.userIdEnds = userIdEnds;
    }

    /** 获取用户ID模糊查询条件 **/
    public String getUserIdLike() {
        return userIdLike;
    }

    /** 设置用户ID模糊查询条件 **/
    public void setUserIdLike(String userIdLike) {
        this.userIdLike = userIdLike;
    }

    /** 判断用户名是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUserNameIsNull() {
        return userNameIsNull;
    }

    /** 设置用户名空值查询(true:空值查询|false:非空值查询) **/
    public void setUserNameIsNull(Boolean userNameIsNull) {
        this.userNameIsNull = userNameIsNull;
    }

    /** 获取用户名前模匹配条件 **/
    public String getUserNameStarts() {
        return userNameStarts;
    }

    /** 设置用户名前模匹配条件 **/
    public void setUserNameStarts(String userNameStarts) {
        this.userNameStarts = userNameStarts;
    }

    /** 获取用户名后模匹配条件 **/
    public String getUserNameEnds() {
        return userNameEnds;
    }

    /** 设置用户名后模匹配条件 **/
    public void setUserNameEnds(String userNameEnds) {
        this.userNameEnds = userNameEnds;
    }

    /** 获取用户名模糊查询条件 **/
    public String getUserNameLike() {
        return userNameLike;
    }

    /** 设置用户名模糊查询条件 **/
    public void setUserNameLike(String userNameLike) {
        this.userNameLike = userNameLike;
    }

    /** 判断商家租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProviderTenantCodeIsNull() {
        return providerTenantCodeIsNull;
    }

    /** 设置商家租户编号空值查询(true:空值查询|false:非空值查询) **/
    public void setProviderTenantCodeIsNull(Boolean providerTenantCodeIsNull) {
        this.providerTenantCodeIsNull = providerTenantCodeIsNull;
    }

    /** 获取商家租户编号前模匹配条件 **/
    public String getProviderTenantCodeStarts() {
        return providerTenantCodeStarts;
    }

    /** 设置商家租户编号前模匹配条件 **/
    public void setProviderTenantCodeStarts(String providerTenantCodeStarts) {
        this.providerTenantCodeStarts = providerTenantCodeStarts;
    }

    /** 获取商家租户编号后模匹配条件 **/
    public String getProviderTenantCodeEnds() {
        return providerTenantCodeEnds;
    }

    /** 设置商家租户编号后模匹配条件 **/
    public void setProviderTenantCodeEnds(String providerTenantCodeEnds) {
        this.providerTenantCodeEnds = providerTenantCodeEnds;
    }

    /** 获取商家租户编号模糊查询条件 **/
    public String getProviderTenantCodeLike() {
        return providerTenantCodeLike;
    }

    /** 设置商家租户编号模糊查询条件 **/
    public void setProviderTenantCodeLike(String providerTenantCodeLike) {
        this.providerTenantCodeLike = providerTenantCodeLike;
    }

    /** 判断客服租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getAgentTenantCodeIsNull() {
        return agentTenantCodeIsNull;
    }

    /** 设置客服租户编号空值查询(true:空值查询|false:非空值查询) **/
    public void setAgentTenantCodeIsNull(Boolean agentTenantCodeIsNull) {
        this.agentTenantCodeIsNull = agentTenantCodeIsNull;
    }

    /** 获取客服租户编号前模匹配条件 **/
    public String getAgentTenantCodeStarts() {
        return agentTenantCodeStarts;
    }

    /** 设置客服租户编号前模匹配条件 **/
    public void setAgentTenantCodeStarts(String agentTenantCodeStarts) {
        this.agentTenantCodeStarts = agentTenantCodeStarts;
    }

    /** 获取客服租户编号后模匹配条件 **/
    public String getAgentTenantCodeEnds() {
        return agentTenantCodeEnds;
    }

    /** 设置客服租户编号后模匹配条件 **/
    public void setAgentTenantCodeEnds(String agentTenantCodeEnds) {
        this.agentTenantCodeEnds = agentTenantCodeEnds;
    }

    /** 获取客服租户编号模糊查询条件 **/
    public String getAgentTenantCodeLike() {
        return agentTenantCodeLike;
    }

    /** 设置客服租户编号模糊查询条件 **/
    public void setAgentTenantCodeLike(String agentTenantCodeLike) {
        this.agentTenantCodeLike = agentTenantCodeLike;
    }

    /** 判断客服ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getAgentIdIsNull() {
        return agentIdIsNull;
    }

    /** 设置客服ID空值查询(true:空值查询|false:非空值查询) **/
    public void setAgentIdIsNull(Boolean agentIdIsNull) {
        this.agentIdIsNull = agentIdIsNull;
    }

    /** 获取客服ID前模匹配条件 **/
    public String getAgentIdStarts() {
        return agentIdStarts;
    }

    /** 设置客服ID前模匹配条件 **/
    public void setAgentIdStarts(String agentIdStarts) {
        this.agentIdStarts = agentIdStarts;
    }

    /** 获取客服ID后模匹配条件 **/
    public String getAgentIdEnds() {
        return agentIdEnds;
    }

    /** 设置客服ID后模匹配条件 **/
    public void setAgentIdEnds(String agentIdEnds) {
        this.agentIdEnds = agentIdEnds;
    }

    /** 获取客服ID模糊查询条件 **/
    public String getAgentIdLike() {
        return agentIdLike;
    }

    /** 设置客服ID模糊查询条件 **/
    public void setAgentIdLike(String agentIdLike) {
        this.agentIdLike = agentIdLike;
    }

    /** 判断客服姓名是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getAgentNameIsNull() {
        return agentNameIsNull;
    }

    /** 设置客服姓名空值查询(true:空值查询|false:非空值查询) **/
    public void setAgentNameIsNull(Boolean agentNameIsNull) {
        this.agentNameIsNull = agentNameIsNull;
    }

    /** 获取客服姓名前模匹配条件 **/
    public String getAgentNameStarts() {
        return agentNameStarts;
    }

    /** 设置客服姓名前模匹配条件 **/
    public void setAgentNameStarts(String agentNameStarts) {
        this.agentNameStarts = agentNameStarts;
    }

    /** 获取客服姓名后模匹配条件 **/
    public String getAgentNameEnds() {
        return agentNameEnds;
    }

    /** 设置客服姓名后模匹配条件 **/
    public void setAgentNameEnds(String agentNameEnds) {
        this.agentNameEnds = agentNameEnds;
    }

    /** 获取客服姓名模糊查询条件 **/
    public String getAgentNameLike() {
        return agentNameLike;
    }

    /** 设置客服姓名模糊查询条件 **/
    public void setAgentNameLike(String agentNameLike) {
        this.agentNameLike = agentNameLike;
    }

    /** 判断是否代客操作是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getAgencyOperateIsNull() {
        return agencyOperateIsNull;
    }

    /**
     * 设置是否代客操作空值查询(true:空值查询|false:非空值查询)
     *
     * @param agencyOperateIsNull 是否代客操作空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setAgencyOperateIsNull(Boolean agencyOperateIsNull) {
        this.agencyOperateIsNull = agencyOperateIsNull;
    }

    /** 判断IP是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getIpIsNull() {
        return ipIsNull;
    }

    /** 设置IP空值查询(true:空值查询|false:非空值查询) **/
    public void setIpIsNull(Boolean ipIsNull) {
        this.ipIsNull = ipIsNull;
    }

    /** 获取IP前模匹配条件 **/
    public String getIpStarts() {
        return ipStarts;
    }

    /** 设置IP前模匹配条件 **/
    public void setIpStarts(String ipStarts) {
        this.ipStarts = ipStarts;
    }

    /** 获取IP后模匹配条件 **/
    public String getIpEnds() {
        return ipEnds;
    }

    /** 设置IP后模匹配条件 **/
    public void setIpEnds(String ipEnds) {
        this.ipEnds = ipEnds;
    }

    /** 获取IP模糊查询条件 **/
    public String getIpLike() {
        return ipLike;
    }

    /** 设置IP模糊查询条件 **/
    public void setIpLike(String ipLike) {
        this.ipLike = ipLike;
    }

    /** 判断城市是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getCityIsNull() {
        return cityIsNull;
    }

    /** 设置城市空值查询(true:空值查询|false:非空值查询) **/
    public void setCityIsNull(Boolean cityIsNull) {
        this.cityIsNull = cityIsNull;
    }

    /** 获取城市前模匹配条件 **/
    public String getCityStarts() {
        return cityStarts;
    }

    /** 设置城市前模匹配条件 **/
    public void setCityStarts(String cityStarts) {
        this.cityStarts = cityStarts;
    }

    /** 获取城市后模匹配条件 **/
    public String getCityEnds() {
        return cityEnds;
    }

    /** 设置城市后模匹配条件 **/
    public void setCityEnds(String cityEnds) {
        this.cityEnds = cityEnds;
    }

    /** 获取城市模糊查询条件 **/
    public String getCityLike() {
        return cityLike;
    }

    /** 设置城市模糊查询条件 **/
    public void setCityLike(String cityLike) {
        this.cityLike = cityLike;
    }

    /** 判断请求类型(1.页面|2.接口)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRequestTypeIsNull() {
        return requestTypeIsNull;
    }

    /**
     * 设置请求类型(1.页面|2.接口)空值查询(true:空值查询|false:非空值查询)
     *
     * @param requestTypeIsNull 请求类型(1.页面|2.接口)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setRequestTypeIsNull(Boolean requestTypeIsNull) {
        this.requestTypeIsNull = requestTypeIsNull;
    }

    /** 获取请求类型(1.页面|2.接口)列表 **/
    public List<LogRequestType> getRequestTypes() {
        return requestTypes;
    }

    /** 设置请求类型(1.页面|2.接口)列表 **/
    public void setRequestTypes(List<LogRequestType> requestTypes) {
        this.requestTypes = requestTypes;
    }

    /** 增加请求类型(1.页面|2.接口) **/
    public void addRequestType(LogRequestType... requestTypes) {
        if (this.requestTypes == null) {
            this.requestTypes = new ArrayList<>();
        }
        this.requestTypes.addAll(Arrays.asList(requestTypes));
    }

    /** 判断请求协议是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRequestProtocolIsNull() {
        return requestProtocolIsNull;
    }

    /** 设置请求协议空值查询(true:空值查询|false:非空值查询) **/
    public void setRequestProtocolIsNull(Boolean requestProtocolIsNull) {
        this.requestProtocolIsNull = requestProtocolIsNull;
    }

    /** 获取请求协议前模匹配条件 **/
    public String getRequestProtocolStarts() {
        return requestProtocolStarts;
    }

    /** 设置请求协议前模匹配条件 **/
    public void setRequestProtocolStarts(String requestProtocolStarts) {
        this.requestProtocolStarts = requestProtocolStarts;
    }

    /** 获取请求协议后模匹配条件 **/
    public String getRequestProtocolEnds() {
        return requestProtocolEnds;
    }

    /** 设置请求协议后模匹配条件 **/
    public void setRequestProtocolEnds(String requestProtocolEnds) {
        this.requestProtocolEnds = requestProtocolEnds;
    }

    /** 获取请求协议模糊查询条件 **/
    public String getRequestProtocolLike() {
        return requestProtocolLike;
    }

    /** 设置请求协议模糊查询条件 **/
    public void setRequestProtocolLike(String requestProtocolLike) {
        this.requestProtocolLike = requestProtocolLike;
    }

    /** 判断请求方法是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRequestMethodIsNull() {
        return requestMethodIsNull;
    }

    /** 设置请求方法空值查询(true:空值查询|false:非空值查询) **/
    public void setRequestMethodIsNull(Boolean requestMethodIsNull) {
        this.requestMethodIsNull = requestMethodIsNull;
    }

    /** 获取请求方法前模匹配条件 **/
    public String getRequestMethodStarts() {
        return requestMethodStarts;
    }

    /** 设置请求方法前模匹配条件 **/
    public void setRequestMethodStarts(String requestMethodStarts) {
        this.requestMethodStarts = requestMethodStarts;
    }

    /** 获取请求方法后模匹配条件 **/
    public String getRequestMethodEnds() {
        return requestMethodEnds;
    }

    /** 设置请求方法后模匹配条件 **/
    public void setRequestMethodEnds(String requestMethodEnds) {
        this.requestMethodEnds = requestMethodEnds;
    }

    /** 获取请求方法模糊查询条件 **/
    public String getRequestMethodLike() {
        return requestMethodLike;
    }

    /** 设置请求方法模糊查询条件 **/
    public void setRequestMethodLike(String requestMethodLike) {
        this.requestMethodLike = requestMethodLike;
    }

    /** 判断请求URL是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRequestUrlIsNull() {
        return requestUrlIsNull;
    }

    /** 设置请求URL空值查询(true:空值查询|false:非空值查询) **/
    public void setRequestUrlIsNull(Boolean requestUrlIsNull) {
        this.requestUrlIsNull = requestUrlIsNull;
    }

    /** 获取请求URL前模匹配条件 **/
    public String getRequestUrlStarts() {
        return requestUrlStarts;
    }

    /** 设置请求URL前模匹配条件 **/
    public void setRequestUrlStarts(String requestUrlStarts) {
        this.requestUrlStarts = requestUrlStarts;
    }

    /** 获取请求URL后模匹配条件 **/
    public String getRequestUrlEnds() {
        return requestUrlEnds;
    }

    /** 设置请求URL后模匹配条件 **/
    public void setRequestUrlEnds(String requestUrlEnds) {
        this.requestUrlEnds = requestUrlEnds;
    }

    /** 获取请求URL模糊查询条件 **/
    public String getRequestUrlLike() {
        return requestUrlLike;
    }

    /** 设置请求URL模糊查询条件 **/
    public void setRequestUrlLike(String requestUrlLike) {
        this.requestUrlLike = requestUrlLike;
    }

    /** 判断请求参数是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRequestParamsIsNull() {
        return requestParamsIsNull;
    }

    /** 设置请求参数空值查询(true:空值查询|false:非空值查询) **/
    public void setRequestParamsIsNull(Boolean requestParamsIsNull) {
        this.requestParamsIsNull = requestParamsIsNull;
    }

    /** 获取请求参数前模匹配条件 **/
    public String getRequestParamsStarts() {
        return requestParamsStarts;
    }

    /** 设置请求参数前模匹配条件 **/
    public void setRequestParamsStarts(String requestParamsStarts) {
        this.requestParamsStarts = requestParamsStarts;
    }

    /** 获取请求参数后模匹配条件 **/
    public String getRequestParamsEnds() {
        return requestParamsEnds;
    }

    /** 设置请求参数后模匹配条件 **/
    public void setRequestParamsEnds(String requestParamsEnds) {
        this.requestParamsEnds = requestParamsEnds;
    }

    /** 获取请求参数模糊查询条件 **/
    public String getRequestParamsLike() {
        return requestParamsLike;
    }

    /** 设置请求参数模糊查询条件 **/
    public void setRequestParamsLike(String requestParamsLike) {
        this.requestParamsLike = requestParamsLike;
    }

    /** 判断执行描述是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getExecuteDescIsNull() {
        return executeDescIsNull;
    }

    /** 设置执行描述空值查询(true:空值查询|false:非空值查询) **/
    public void setExecuteDescIsNull(Boolean executeDescIsNull) {
        this.executeDescIsNull = executeDescIsNull;
    }

    /** 获取执行描述前模匹配条件 **/
    public String getExecuteDescStarts() {
        return executeDescStarts;
    }

    /** 设置执行描述前模匹配条件 **/
    public void setExecuteDescStarts(String executeDescStarts) {
        this.executeDescStarts = executeDescStarts;
    }

    /** 获取执行描述后模匹配条件 **/
    public String getExecuteDescEnds() {
        return executeDescEnds;
    }

    /** 设置执行描述后模匹配条件 **/
    public void setExecuteDescEnds(String executeDescEnds) {
        this.executeDescEnds = executeDescEnds;
    }

    /** 获取执行描述模糊查询条件 **/
    public String getExecuteDescLike() {
        return executeDescLike;
    }

    /** 设置执行描述模糊查询条件 **/
    public void setExecuteDescLike(String executeDescLike) {
        this.executeDescLike = executeDescLike;
    }

    /** 判断执行方法是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getExecuteMethodIsNull() {
        return executeMethodIsNull;
    }

    /** 设置执行方法空值查询(true:空值查询|false:非空值查询) **/
    public void setExecuteMethodIsNull(Boolean executeMethodIsNull) {
        this.executeMethodIsNull = executeMethodIsNull;
    }

    /** 获取执行方法前模匹配条件 **/
    public String getExecuteMethodStarts() {
        return executeMethodStarts;
    }

    /** 设置执行方法前模匹配条件 **/
    public void setExecuteMethodStarts(String executeMethodStarts) {
        this.executeMethodStarts = executeMethodStarts;
    }

    /** 获取执行方法后模匹配条件 **/
    public String getExecuteMethodEnds() {
        return executeMethodEnds;
    }

    /** 设置执行方法后模匹配条件 **/
    public void setExecuteMethodEnds(String executeMethodEnds) {
        this.executeMethodEnds = executeMethodEnds;
    }

    /** 获取执行方法模糊查询条件 **/
    public String getExecuteMethodLike() {
        return executeMethodLike;
    }

    /** 设置执行方法模糊查询条件 **/
    public void setExecuteMethodLike(String executeMethodLike) {
        this.executeMethodLike = executeMethodLike;
    }

    /** 判断执行时间是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getExecuteTimeIsNull() {
        return executeTimeIsNull;
    }

    /** 设置执行时间空值查询(true:空值查询|false:非空值查询) **/
    public void setExecuteTimeIsNull(Boolean executeTimeIsNull) {
        this.executeTimeIsNull = executeTimeIsNull;
    }

    /** 获取最小执行时间 **/
    public Integer getExecuteTimeMin() {
        return executeTimeMin;
    }

    /** 设置最小执行时间 **/
    public void setExecuteTimeMin(Integer executeTimeMin) {
        this.executeTimeMin = executeTimeMin;
    }

    /** 获取最大执行时间 **/
    public Integer getExecuteTimeMax() {
        return executeTimeMax;
    }

    /** 设置最大执行时间 **/
    public void setExecuteTimeMax(Integer executeTimeMax) {
        this.executeTimeMax = executeTimeMax;
    }

    /** 判断调用DB次数是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDbInvokeTimesIsNull() {
        return dbInvokeTimesIsNull;
    }

    /** 设置调用DB次数空值查询(true:空值查询|false:非空值查询) **/
    public void setDbInvokeTimesIsNull(Boolean dbInvokeTimesIsNull) {
        this.dbInvokeTimesIsNull = dbInvokeTimesIsNull;
    }

    /** 获取最小调用DB次数 **/
    public Integer getDbInvokeTimesMin() {
        return dbInvokeTimesMin;
    }

    /** 设置最小调用DB次数 **/
    public void setDbInvokeTimesMin(Integer dbInvokeTimesMin) {
        this.dbInvokeTimesMin = dbInvokeTimesMin;
    }

    /** 获取最大调用DB次数 **/
    public Integer getDbInvokeTimesMax() {
        return dbInvokeTimesMax;
    }

    /** 设置最大调用DB次数 **/
    public void setDbInvokeTimesMax(Integer dbInvokeTimesMax) {
        this.dbInvokeTimesMax = dbInvokeTimesMax;
    }

    /** 判断结果类型(1.成功|2.失败|3.未知)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getReturnTypeIsNull() {
        return returnTypeIsNull;
    }

    /**
     * 设置结果类型(1.成功|2.失败|3.未知)空值查询(true:空值查询|false:非空值查询)
     *
     * @param returnTypeIsNull 结果类型(1.成功|2.失败|3.未知)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setReturnTypeIsNull(Boolean returnTypeIsNull) {
        this.returnTypeIsNull = returnTypeIsNull;
    }

    /** 获取结果类型(1.成功|2.失败|3.未知)列表 **/
    public List<LogResultType> getReturnTypes() {
        return returnTypes;
    }

    /** 设置结果类型(1.成功|2.失败|3.未知)列表 **/
    public void setReturnTypes(List<LogResultType> returnTypes) {
        this.returnTypes = returnTypes;
    }

    /** 增加结果类型(1.成功|2.失败|3.未知) **/
    public void addReturnType(LogResultType... returnTypes) {
        if (this.returnTypes == null) {
            this.returnTypes = new ArrayList<>();
        }
        this.returnTypes.addAll(Arrays.asList(returnTypes));
    }

    /** 判断返回码是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getReturnCodeIsNull() {
        return returnCodeIsNull;
    }

    /** 设置返回码空值查询(true:空值查询|false:非空值查询) **/
    public void setReturnCodeIsNull(Boolean returnCodeIsNull) {
        this.returnCodeIsNull = returnCodeIsNull;
    }

    /** 获取返回码前模匹配条件 **/
    public String getReturnCodeStarts() {
        return returnCodeStarts;
    }

    /** 设置返回码前模匹配条件 **/
    public void setReturnCodeStarts(String returnCodeStarts) {
        this.returnCodeStarts = returnCodeStarts;
    }

    /** 获取返回码后模匹配条件 **/
    public String getReturnCodeEnds() {
        return returnCodeEnds;
    }

    /** 设置返回码后模匹配条件 **/
    public void setReturnCodeEnds(String returnCodeEnds) {
        this.returnCodeEnds = returnCodeEnds;
    }

    /** 获取返回码模糊查询条件 **/
    public String getReturnCodeLike() {
        return returnCodeLike;
    }

    /** 设置返回码模糊查询条件 **/
    public void setReturnCodeLike(String returnCodeLike) {
        this.returnCodeLike = returnCodeLike;
    }

    /** 判断返回内容是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getReturnContentIsNull() {
        return returnContentIsNull;
    }

    /** 设置返回内容空值查询(true:空值查询|false:非空值查询) **/
    public void setReturnContentIsNull(Boolean returnContentIsNull) {
        this.returnContentIsNull = returnContentIsNull;
    }

    /** 获取返回内容前模匹配条件 **/
    public String getReturnContentStarts() {
        return returnContentStarts;
    }

    /** 设置返回内容前模匹配条件 **/
    public void setReturnContentStarts(String returnContentStarts) {
        this.returnContentStarts = returnContentStarts;
    }

    /** 获取返回内容后模匹配条件 **/
    public String getReturnContentEnds() {
        return returnContentEnds;
    }

    /** 设置返回内容后模匹配条件 **/
    public void setReturnContentEnds(String returnContentEnds) {
        this.returnContentEnds = returnContentEnds;
    }

    /** 获取返回内容模糊查询条件 **/
    public String getReturnContentLike() {
        return returnContentLike;
    }

    /** 设置返回内容模糊查询条件 **/
    public void setReturnContentLike(String returnContentLike) {
        this.returnContentLike = returnContentLike;
    }

    /** 判断来源页是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRefererUrlIsNull() {
        return refererUrlIsNull;
    }

    /** 设置来源页空值查询(true:空值查询|false:非空值查询) **/
    public void setRefererUrlIsNull(Boolean refererUrlIsNull) {
        this.refererUrlIsNull = refererUrlIsNull;
    }

    /** 获取来源页前模匹配条件 **/
    public String getRefererUrlStarts() {
        return refererUrlStarts;
    }

    /** 设置来源页前模匹配条件 **/
    public void setRefererUrlStarts(String refererUrlStarts) {
        this.refererUrlStarts = refererUrlStarts;
    }

    /** 获取来源页后模匹配条件 **/
    public String getRefererUrlEnds() {
        return refererUrlEnds;
    }

    /** 设置来源页后模匹配条件 **/
    public void setRefererUrlEnds(String refererUrlEnds) {
        this.refererUrlEnds = refererUrlEnds;
    }

    /** 获取来源页模糊查询条件 **/
    public String getRefererUrlLike() {
        return refererUrlLike;
    }

    /** 设置来源页模糊查询条件 **/
    public void setRefererUrlLike(String refererUrlLike) {
        this.refererUrlLike = refererUrlLike;
    }

    /** 判断入口是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getEntranceIsNull() {
        return entranceIsNull;
    }

    /** 设置入口空值查询(true:空值查询|false:非空值查询) **/
    public void setEntranceIsNull(Boolean entranceIsNull) {
        this.entranceIsNull = entranceIsNull;
    }

    /** 判断来源类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRefererTypeIsNull() {
        return refererTypeIsNull;
    }

    /** 设置来源类型空值查询(true:空值查询|false:非空值查询) **/
    public void setRefererTypeIsNull(Boolean refererTypeIsNull) {
        this.refererTypeIsNull = refererTypeIsNull;
    }

    /** 获取来源类型前模匹配条件 **/
    public String getRefererTypeStarts() {
        return refererTypeStarts;
    }

    /** 设置来源类型前模匹配条件 **/
    public void setRefererTypeStarts(String refererTypeStarts) {
        this.refererTypeStarts = refererTypeStarts;
    }

    /** 获取来源类型后模匹配条件 **/
    public String getRefererTypeEnds() {
        return refererTypeEnds;
    }

    /** 设置来源类型后模匹配条件 **/
    public void setRefererTypeEnds(String refererTypeEnds) {
        this.refererTypeEnds = refererTypeEnds;
    }

    /** 获取来源类型模糊查询条件 **/
    public String getRefererTypeLike() {
        return refererTypeLike;
    }

    /** 设置来源类型模糊查询条件 **/
    public void setRefererTypeLike(String refererTypeLike) {
        this.refererTypeLike = refererTypeLike;
    }

    /** 判断来源关键词是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getRefererKeywordIsNull() {
        return refererKeywordIsNull;
    }

    /** 设置来源关键词空值查询(true:空值查询|false:非空值查询) **/
    public void setRefererKeywordIsNull(Boolean refererKeywordIsNull) {
        this.refererKeywordIsNull = refererKeywordIsNull;
    }

    /** 获取来源关键词前模匹配条件 **/
    public String getRefererKeywordStarts() {
        return refererKeywordStarts;
    }

    /** 设置来源关键词前模匹配条件 **/
    public void setRefererKeywordStarts(String refererKeywordStarts) {
        this.refererKeywordStarts = refererKeywordStarts;
    }

    /** 获取来源关键词后模匹配条件 **/
    public String getRefererKeywordEnds() {
        return refererKeywordEnds;
    }

    /** 设置来源关键词后模匹配条件 **/
    public void setRefererKeywordEnds(String refererKeywordEnds) {
        this.refererKeywordEnds = refererKeywordEnds;
    }

    /** 获取来源关键词模糊查询条件 **/
    public String getRefererKeywordLike() {
        return refererKeywordLike;
    }

    /** 设置来源关键词模糊查询条件 **/
    public void setRefererKeywordLike(String refererKeywordLike) {
        this.refererKeywordLike = refererKeywordLike;
    }

    /** 判断UserAgent是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUserAgentIsNull() {
        return userAgentIsNull;
    }

    /** 设置UserAgent空值查询(true:空值查询|false:非空值查询) **/
    public void setUserAgentIsNull(Boolean userAgentIsNull) {
        this.userAgentIsNull = userAgentIsNull;
    }

    /** 获取UserAgent前模匹配条件 **/
    public String getUserAgentStarts() {
        return userAgentStarts;
    }

    /** 设置UserAgent前模匹配条件 **/
    public void setUserAgentStarts(String userAgentStarts) {
        this.userAgentStarts = userAgentStarts;
    }

    /** 获取UserAgent后模匹配条件 **/
    public String getUserAgentEnds() {
        return userAgentEnds;
    }

    /** 设置UserAgent后模匹配条件 **/
    public void setUserAgentEnds(String userAgentEnds) {
        this.userAgentEnds = userAgentEnds;
    }

    /** 获取UserAgent模糊查询条件 **/
    public String getUserAgentLike() {
        return userAgentLike;
    }

    /** 设置UserAgent模糊查询条件 **/
    public void setUserAgentLike(String userAgentLike) {
        this.userAgentLike = userAgentLike;
    }

    /** 判断浏览器类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getBrowserTypeIsNull() {
        return browserTypeIsNull;
    }

    /** 设置浏览器类型空值查询(true:空值查询|false:非空值查询) **/
    public void setBrowserTypeIsNull(Boolean browserTypeIsNull) {
        this.browserTypeIsNull = browserTypeIsNull;
    }

    /** 获取浏览器类型前模匹配条件 **/
    public String getBrowserTypeStarts() {
        return browserTypeStarts;
    }

    /** 设置浏览器类型前模匹配条件 **/
    public void setBrowserTypeStarts(String browserTypeStarts) {
        this.browserTypeStarts = browserTypeStarts;
    }

    /** 获取浏览器类型后模匹配条件 **/
    public String getBrowserTypeEnds() {
        return browserTypeEnds;
    }

    /** 设置浏览器类型后模匹配条件 **/
    public void setBrowserTypeEnds(String browserTypeEnds) {
        this.browserTypeEnds = browserTypeEnds;
    }

    /** 获取浏览器类型模糊查询条件 **/
    public String getBrowserTypeLike() {
        return browserTypeLike;
    }

    /** 设置浏览器类型模糊查询条件 **/
    public void setBrowserTypeLike(String browserTypeLike) {
        this.browserTypeLike = browserTypeLike;
    }

    /** 判断浏览器版本是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getBrowserVersionIsNull() {
        return browserVersionIsNull;
    }

    /** 设置浏览器版本空值查询(true:空值查询|false:非空值查询) **/
    public void setBrowserVersionIsNull(Boolean browserVersionIsNull) {
        this.browserVersionIsNull = browserVersionIsNull;
    }

    /** 获取浏览器版本前模匹配条件 **/
    public String getBrowserVersionStarts() {
        return browserVersionStarts;
    }

    /** 设置浏览器版本前模匹配条件 **/
    public void setBrowserVersionStarts(String browserVersionStarts) {
        this.browserVersionStarts = browserVersionStarts;
    }

    /** 获取浏览器版本后模匹配条件 **/
    public String getBrowserVersionEnds() {
        return browserVersionEnds;
    }

    /** 设置浏览器版本后模匹配条件 **/
    public void setBrowserVersionEnds(String browserVersionEnds) {
        this.browserVersionEnds = browserVersionEnds;
    }

    /** 获取浏览器版本模糊查询条件 **/
    public String getBrowserVersionLike() {
        return browserVersionLike;
    }

    /** 设置浏览器版本模糊查询条件 **/
    public void setBrowserVersionLike(String browserVersionLike) {
        this.browserVersionLike = browserVersionLike;
    }

    /** 判断操作系统类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOsTypeIsNull() {
        return osTypeIsNull;
    }

    /** 设置操作系统类型空值查询(true:空值查询|false:非空值查询) **/
    public void setOsTypeIsNull(Boolean osTypeIsNull) {
        this.osTypeIsNull = osTypeIsNull;
    }

    /** 获取操作系统类型前模匹配条件 **/
    public String getOsTypeStarts() {
        return osTypeStarts;
    }

    /** 设置操作系统类型前模匹配条件 **/
    public void setOsTypeStarts(String osTypeStarts) {
        this.osTypeStarts = osTypeStarts;
    }

    /** 获取操作系统类型后模匹配条件 **/
    public String getOsTypeEnds() {
        return osTypeEnds;
    }

    /** 设置操作系统类型后模匹配条件 **/
    public void setOsTypeEnds(String osTypeEnds) {
        this.osTypeEnds = osTypeEnds;
    }

    /** 获取操作系统类型模糊查询条件 **/
    public String getOsTypeLike() {
        return osTypeLike;
    }

    /** 设置操作系统类型模糊查询条件 **/
    public void setOsTypeLike(String osTypeLike) {
        this.osTypeLike = osTypeLike;
    }

    /** 判断操作系统版本是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOsVersionIsNull() {
        return osVersionIsNull;
    }

    /** 设置操作系统版本空值查询(true:空值查询|false:非空值查询) **/
    public void setOsVersionIsNull(Boolean osVersionIsNull) {
        this.osVersionIsNull = osVersionIsNull;
    }

    /** 获取操作系统版本前模匹配条件 **/
    public String getOsVersionStarts() {
        return osVersionStarts;
    }

    /** 设置操作系统版本前模匹配条件 **/
    public void setOsVersionStarts(String osVersionStarts) {
        this.osVersionStarts = osVersionStarts;
    }

    /** 获取操作系统版本后模匹配条件 **/
    public String getOsVersionEnds() {
        return osVersionEnds;
    }

    /** 设置操作系统版本后模匹配条件 **/
    public void setOsVersionEnds(String osVersionEnds) {
        this.osVersionEnds = osVersionEnds;
    }

    /** 获取操作系统版本模糊查询条件 **/
    public String getOsVersionLike() {
        return osVersionLike;
    }

    /** 设置操作系统版本模糊查询条件 **/
    public void setOsVersionLike(String osVersionLike) {
        this.osVersionLike = osVersionLike;
    }

    /** 判断设备类型是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDeviceTypeIsNull() {
        return deviceTypeIsNull;
    }

    /** 设置设备类型空值查询(true:空值查询|false:非空值查询) **/
    public void setDeviceTypeIsNull(Boolean deviceTypeIsNull) {
        this.deviceTypeIsNull = deviceTypeIsNull;
    }

    /** 获取设备类型前模匹配条件 **/
    public String getDeviceTypeStarts() {
        return deviceTypeStarts;
    }

    /** 设置设备类型前模匹配条件 **/
    public void setDeviceTypeStarts(String deviceTypeStarts) {
        this.deviceTypeStarts = deviceTypeStarts;
    }

    /** 获取设备类型后模匹配条件 **/
    public String getDeviceTypeEnds() {
        return deviceTypeEnds;
    }

    /** 设置设备类型后模匹配条件 **/
    public void setDeviceTypeEnds(String deviceTypeEnds) {
        this.deviceTypeEnds = deviceTypeEnds;
    }

    /** 获取设备类型模糊查询条件 **/
    public String getDeviceTypeLike() {
        return deviceTypeLike;
    }

    /** 设置设备类型模糊查询条件 **/
    public void setDeviceTypeLike(String deviceTypeLike) {
        this.deviceTypeLike = deviceTypeLike;
    }

    /** 判断处理状态(1.未处理|2.已处理)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getProcessStateIsNull() {
        return processStateIsNull;
    }

    /**
     * 设置处理状态(1.未处理|2.已处理)空值查询(true:空值查询|false:非空值查询)
     *
     * @param processStateIsNull 处理状态(1.未处理|2.已处理)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setProcessStateIsNull(Boolean processStateIsNull) {
        this.processStateIsNull = processStateIsNull;
    }

    /** 获取处理状态(1.未处理|2.已处理)列表 **/
    public List<LogProcessState> getProcessStates() {
        return processStates;
    }

    /** 设置处理状态(1.未处理|2.已处理)列表 **/
    public void setProcessStates(List<LogProcessState> processStates) {
        this.processStates = processStates;
    }

    /** 增加处理状态(1.未处理|2.已处理) **/
    public void addProcessState(LogProcessState... processStates) {
        if (this.processStates == null) {
            this.processStates = new ArrayList<>();
        }
        this.processStates.addAll(Arrays.asList(processStates));
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMin() {
        return createTimeMin;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMin(Date createTimeMin) {
        this.createTimeMin = createTimeMin;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMax() {
        return createTimeMax;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMax(Date createTimeMax) {
        this.createTimeMax = createTimeMax;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMinWithDay() {
        return createTimeMinWithDay;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMinWithDay(Date createTimeMinWithDay) {
        this.createTimeMinWithDay = createTimeMinWithDay;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMaxWithDay() {
        return createTimeMaxWithDay;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMaxWithDay(Date createTimeMaxWithDay) {
        this.createTimeMaxWithDay = createTimeMaxWithDay;
    }

    /** 判断选项是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOptionsIsNull() {
        return optionsIsNull;
    }

    /** 设置选项空值查询(true:空值查询|false:非空值查询) **/
    public void setOptionsIsNull(Boolean optionsIsNull) {
        this.optionsIsNull = optionsIsNull;
    }

}